
package com.tistory.commons.utils;

import java.awt.AlphaComposite;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;

import javax.imageio.ImageIO;
//
//import org.apache.commons.io.IOUtils;
//import org.apache.commons.lang.ArrayUtils;
//import org.apache.commons.logging.Log;
//import org.apache.commons.logging.LogFactory;
//
//import com.skcomms.ximg.XImg;


/**
 *
 * @author Owner
 */
public class ImageUtil
{
//
//    protected static Log logger = LogFactory.getLog(ImageUtil.class);
//    
//    public static final String IMAGE_TYPE_JPGE = "jpge";
//    public static final String IMAGE_TYPE_PNG = "png";
//    public static final String IMAGE_TYPE_BMP = "bmp";
//    public static final String IMAGE_TYPE_GIP = "gif";
//    
//    /**
//     * 2차원 배열 형식으로 여러 이미지를 하나의 이미지로 결합하여 반환.<br>
//     * <br>
//     * [example]<br>
//     * String [] filePath = {"d:\\a1.jpg", "d:\\a2.jpg"};<br>
//     * List<String> imagesPath = Arrays.asList(filePath);<br>
//     * try {<br>
//     * 	BufferedImage finalImg = ImageUtil.mergeImages(1, 2, BufferedImage.TYPE_INT_RGB, imagesPath, true);<br>
//     * 	ImageIO.write(finalImg, "jpeg", new File("d:\\f.jpg"));<br>
//     * } catch (IOException e) {<br>
//     * 	...<br>
//     * }<br>
//     * @param rows - 행 수
//     * @param cols - 열 수
//     * @param images - 결합 대상 이미지 파일 경로
//     * @param resize - 이미지 크기 변경 여부
//     * @return 결합된 최종 이미지 객체
//     */
//    public static BufferedImage mergeImgsAsTwoDimArrays(int rows, int cols, List<String> imagesPath, boolean resize) throws IOException {
//
//    	int chunks = rows * cols;  
//		
//		int chunkWidth = 0, chunkHeight = 0;  
//
//		BufferedImage[] buffImages = new BufferedImage[chunks];  		
//		
//		/*1. 이미지 객체 Load & chunk width, height 결정 */
//		for (int i = 0; i < imagesPath.size(); i++) {
//			buffImages[i] = ImageIO.read(new File(imagesPath.get(i)));
//			chunkWidth = (chunkWidth < buffImages[i].getWidth() ? buffImages[i].getWidth() : chunkWidth);
//			chunkHeight = (chunkHeight < buffImages[i].getHeight() ? buffImages[i].getHeight() : chunkHeight);
//		}
//		
//		/*2. resize == true 경우 이미지를 chunk Cell 크기에 맞게 재조정 */
//		if (resize) {
//			for (int i = 0; i < chunks; i++) {  
//				BufferedImage bufferedImage = new BufferedImage(chunkWidth, chunkHeight, buffImages[i].getType());
//				Graphics2D graphics2D = bufferedImage.createGraphics();
//				graphics2D.setComposite(AlphaComposite.Src);
//				graphics2D.drawImage(buffImages[i], 0, 0, chunkWidth, chunkHeight, null);
//				graphics2D.dispose();
//				buffImages[i] = bufferedImage;
//			} 		
//		}
//		
//		/*3. 최종 이미지 초기화 */
//		BufferedImage finalImg = new BufferedImage(chunkWidth*cols, chunkHeight*rows, buffImages[0].getType());  
//		
//		int num = 0;  
//
//		/*4. 최종 이미지의 각 cell 영역에 해당 이미지 객체 그리기 */
//		for (int i = 0; i < rows; i++) {  
//			for (int j = 0; j < cols; j++) {  
//				finalImg.createGraphics().drawImage(buffImages[num], chunkWidth * j, chunkHeight * i, buffImages[num].getWidth(), buffImages[num].getHeight(), null);  
//				num++;  
//			}  
//		}  
//
//		return finalImg;
//    }
//    
//    /**
//     * 입력된 파일명으로 들어온 파일이 이미지인지 확인한다.
//     * @param srcFile
//     * @return
//     */
//    public static boolean isImage(String srcFile)
//    {
//        try
//        {
//            File inImgfle = new File(srcFile);
//            Image inImage = ImageIO.read(inImgfle);
//            
//            inImage.getSource();
//        }catch(Exception e){
//            return false;       
//        }
//        
//        return true;
//    }
//    
//    /**
//     * 이미지의 크기를 조절한다.
//     * @param source_file 소스 이미지 파일명 (경로포함)
//     * @param out_file 변경 후 이미지 파일명 (경로포함)
//     * @param targetWidth 
//     * @param targetHeight
//     * @return
//     */
//    public static boolean setImgScale(
//            String source_file,
//            String out_file,
//            int targetWidth,
//            int targetHeight)
//        {
//            return setImgScale (source_file, out_file, targetWidth, targetHeight, null);
//        }
//    
//    /**
//     * 이미지의 크기를 조절한다.
//     * @param source_file 소스 이미지 파일명 (경로포함)
//     * @param out_file 변경 후 이미지 파일명 (경로포함)
//     * @param targetWidth 
//     * @param targetHeight
//     * @param directoryName 변경 후 이미지 저장 디렉토리 명
//     * @return
//     */
//    public static boolean setImgScale(
//        String source_file,
//        String out_file,
//        int targetWidth,
//        int targetHeight,
//        String directoryName)
//    {
//        try
//        {
//            File fsrc = new File(source_file);
//            
//            if (fsrc.isFile())
//            {
//                logger.debug("소스 파일이 존재한다.");
//            }
//            else
//            {
//                logger.debug("소스 파일이 존재하지 않는다.");
//                return false;
//            }
//            
//            File outputfile = new File(out_file);
//            if(outputfile.exists()==true) 
//            {
//                logger.info("변경하려는 파일과 동일한 파일이 존재하여 삭제합나디. 파일명 ["+outputfile.getName()+"]");
//                outputfile.delete();
//            } 
//            
//            
//            if(directoryName != null) {
//                if (!FileUtil.directoryCheck(directoryName))
//                    FileUtil.createDirectory(directoryName);
//            } else {
//                if (!FileUtil.directoryCheck(out_file))
//                    FileUtil.createDirectory(out_file);
//            }
//            
//            XImg.initThread();
//                
//            // XImg tmp;
//            XImg img = XImg.create();
//            img.load(source_file);
//            img.resize(targetWidth, targetHeight);
//            img.savePng(out_file);
//                                   
//        } 
//        catch (Exception e)  
//        {
//            try
//            {
//                //FileUtil.fileCopy(source_file, out_file);
//            }
//            catch (Exception ex)
//            {
//                return false;
//            }
//        } 
//        finally 
//        {
//            XImg.cleanupThread();
//        }
//
//        return true;
//    }
//    
//    
//    
//    /**
//     * 이미지의 크기를 조절한다.
//     * @param inImgfle 소스파일
//     * @param out_file 변경 후 이미지 파일명 (경로포함)
//     * @param targetWidth 
//     * @param targetHeight
//     * @return
//     */
//    public static boolean setImgScale(
//        File inImgfle,
//        String out_file,
//        int targetWidth,
//        int targetHeight)
//    {
//        return setImgScale(inImgfle, out_file, targetWidth, targetHeight, null);
//    }
//    
//    /**
//     * 이미지의 크기를 조절한다.
//     * @param inImgfle 소스파일
//     * @param out_file 변경 후 이미지 파일명 (경로포함)
//     * @param targetWidth 
//     * @param targetHeight
//     * @param directoryName 변경 후 이미지 저장 디렉토리 명
//     * @return
//     */
//    public static boolean setImgScale(
//        File inImgfle,
//        String out_file,
//        int targetWidth,
//        int targetHeight,
//        String directoryName)
//    {
//        try
//        {            
//            if (inImgfle.isFile())
//            {            
//                logger.debug("소스 파일이 존재한다.");
//            }
//            else
//            {
//                logger.debug("소스 파일이 존재하지 않는다.");
//                return false;
//            }
//            
//            File outputfile = new File(out_file);
//            if(outputfile.exists()==true) 
//            {
//                logger.info("변경하려는 파일과 동일한 파일이 존재하여 삭제합나디. 파일명 ["+outputfile.getName()+"]");
//                outputfile.delete();
//            } 
//            
//            if(directoryName != null) {
//                if (!FileUtil.directoryCheck(directoryName))
//                    FileUtil.createDirectory(directoryName);
//            } else {
//                if (!FileUtil.directoryCheck(out_file))
//                    FileUtil.createDirectory(out_file);
//            }
//            
//            XImg.initThread();
//                
//            // XImg tmp;
//            XImg img = XImg.create();
//            img.load(inImgfle.getPath());
//            img.resize(targetWidth, targetHeight);
//            img.savePng(out_file);
//
//        }
//        catch (Exception e)
//        {
//            
//        } finally {
//            XImg.cleanupThread();
//        }
//
//        return true;
//    }
//    
//    
//    /**
//     * 이미지에 효과를 부여하고 크기를 조절한다. 
//     * @param source_file 원본 파일명 (경로포함)
//     * @param out_file 변환 후 파일명 (경로포함)
//     * @param targetWidth 변환할 크기
//     * @param targetHeight 변환할 크기
//     * @param effect 이미지 효과 기본 정보(경로포함)를 담고 있는 배열객체 (round_mask, filter_mask, drop_shadow 순)
//     * @param expand (왼쪽에 추가될 픽셀 크기, 위쪽에 추가될 픽셀 크기, 오른쪽에 추가될 픽셀 크기, 아래쪽에 추가될 픽셀 크기, 추가될 영역의 배경색 RGB)
//     * @return
//     */
//    public static boolean setImgEffect(
//            String sourceFile,
//            String outFile,
//            int targetWidth,
//            int targetHeight,
//            String[] effect,
//            int[] expand,
//            String outFileType)
//    {
//       return setImgEffect(sourceFile, outFile, targetWidth, targetHeight, effect, expand, outFileType, null);
//    }
//    
//    /**
//     * 이미지에 효과를 부여하고 크기를 조절한다. 
//     * @param source_file 원본 파일명 (경로포함)
//     * @param out_file 변환 후 파일명 (경로포함)
//     * @param targetWidth 변환할 크기
//     * @param targetHeight 변환할 크기
//     * @param effect 이미지 효과 기본 정보(경로포함)를 담고 있는 배열객체 (round_mask, filter_mask, drop_shadow 순)
//     * @param expand (왼쪽에 추가될 픽셀 크기, 위쪽에 추가될 픽셀 크기, 오른쪽에 추가될 픽셀 크기, 아래쪽에 추가될 픽셀 크기, 추가될 영역의 배경색 RGB)
//     * @param reduce (가로 오프셋(픽셀),y 세로 오프셋(픽셀),width 오프셋으로 부터의 넓이(픽셀),height 오프셋으로 부터의 높이(픽셀)) 
//     * @return
//     */
//    public static boolean setImgEffect(
//            String sourceFile,
//            String outFile,
//            int targetWidth,
//            int targetHeight,
//            String[] effect,
//            int[] expand,
//            int[] reduce,
//            String outFileType)
//    {
//       return setImgEffect(sourceFile, outFile, targetWidth, targetHeight, effect, expand, reduce, outFileType, null);
//    }
//    
//    /**
//     * 이미지에 효과를 부여하고 크기를 조절한다. 
//     * @param source_file 원본 파일명 (경로포함)
//     * @param out_file 변환 후 파일명 (경로포함)
//     * @param targetWidth 변환할 크기
//     * @param targetHeight 변환할 크기
//     * @param effect 이미지 효과 기본 정보(경로포함)를 담고 있는 배열객체 (round_mask, filter_mask, drop_shadow 순)
//     * @param expand (왼쪽에 추가될 픽셀 크기, 위쪽에 추가될 픽셀 크기, 오른쪽에 추가될 픽셀 크기, 아래쪽에 추가될 픽셀 크기)
//     * @param directoryName
//     * @return
//     */
//   public static boolean setImgEffect(
//            String sourceFile,
//            String outFile,
//            int targetWidth,
//            int targetHeight,
//            String[] effect,
//            int[] expand,
//            String outFileType,
//            String directoryName)
//    {
//
//       XImg m1 = null;
//       XImg m2 = null;
//       XImg m3 = null;
//       
//       try {
//
//            if (directoryName != null) {
//                if (!FileUtil.directoryCheck(directoryName))
//                    FileUtil.createDirectory(directoryName);
//            }
//            else {
//                if (!FileUtil.directoryCheck(outFile))
//                    FileUtil.createDirectory(outFile);
//            }
//            logger.info("initThread()...........");
//            /* 쓰레드 초기화 */
//            XImg.initThread();
//            logger.info("//initThread()...........");
//            XImg tmp;
//            XImg img = XImg.create();
//
//            logger.info("image loading & resizing...........");
//            /* 이미지 로딩 및 리사이징 */
//            img.load(sourceFile);
//
//            img.resize(targetWidth, targetHeight);
//            img.expand(expand[0], expand[1], expand[2], expand[3], 0xFFFFFF);
//            logger.info("//image loading & resizing...........");
//            logger.info("apply effect ...........");
//            String effectImg1 = null;
//            String effectImg2 = null;
//            String effectImg3 = null;
//            
//            if(effect.length == 3) {
//                effectImg1 = effect[0];
//                effectImg2 = effect[1];
//                effectImg3 = effect[2];
//            } else if(effect.length == 2) {
//                effectImg1 = effect[0];
//                effectImg2 = effect[1];
//            } else if(effect.length == 1) {
//                effectImg1 = effect[0];
//            }
//               
//                
//            if(!"".equals(effectImg1) && effectImg1 != null) {
//                m1 = XImg.createGlobal();
//                m1.load(effectImg1);
//            }
//               
//            if(!"".equals(effectImg2) && effectImg2 != null) {
//                m2 = XImg.createGlobal();
//                m2.load(effectImg2);
//            }
//               
//            if(!"".equals(effectImg3) && effectImg3 != null) {
//                m3 = XImg.createGlobal();
//                m3.load(effectImg3);
//            }
//            
//            
//            /*
//             * 로드된 이미지에 필터를 적용해 변환한 후 저장한다. 이미지를 복제해 사용하는 이유는, 동일한 이미지에 다른
//             * 필터를 적용한 또다른 결과를 만들기 위해 원본을 유지할 필요가 있기 때문이다.
//             */
//            tmp = (XImg)img.clone(); // 이미지 변환을 위해 복제
//            tmp.mixMasks(m1, m2, m3);
//            logger.info("//apply effect ...........");
//            logger.info("save image ...........");
//            if(IMAGE_TYPE_BMP.equals(outFileType)) 
//                tmp.saveBmp(outFile);
//            else if(IMAGE_TYPE_GIP.equals(outFileType))
//                tmp.saveGif(outFile);
//            else if (IMAGE_TYPE_JPGE.equals(outFileType))
//                tmp.saveJpeg(outFile, 100);
//            else {
//                tmp.savePng(outFile);
//                removeChuckdKGD(outFile);
//            }
//            logger.info("//save image ...........");
//                
//           // } else {
//           //     logger.error("이미지 변환 실패 [이미지 효과 설정 파일 입력 오류 ]");
//            //    return false;
//           // }
//        } catch (Exception e) {
//            logger.error("이미지 변환 실패 : " + e.getMessage());
//            return false;
//        } finally {
//            /*
//             * 쓰레드 클린업. try 블럭에서 생성했던 모든 이미지 객체가 여기서 삭제된다.
//             */
//        	logger.info("cleanupThread() ...........");
//            XImg.cleanupThread();
//            logger.info("//cleanupThread() ...........");
//
//            /*
//             * 마스크 이미지는 createGlobal로 성성했기 때문에 cleanupThread로는 삭제되지 않는다.
//             */
//            logger.info("dispose mask image ...........");
//            if(m1 != null) m1.dispose();
//            if(m2 != null) m2.dispose();
//            if(m3 != null) m3.dispose();
//            logger.info("//dispose mask image ...........");
//        }
//        return true;
//    }
//   
//   /**
//    * 이미지에 효과를 부여하고 크기를 조절한다. 
//    * @param source_file 원본 파일명 (경로포함)
//    * @param out_file 변환 후 파일명 (경로포함)
//    * @param targetWidth 변환할 크기
//    * @param targetHeight 변환할 크기
//    * @param effect 이미지 효과 기본 정보(경로포함)를 담고 있는 배열객체 (round_mask, filter_mask, drop_shadow 순)
//    * @param expand (왼쪽에 추가될 픽셀 크기, 위쪽에 추가될 픽셀 크기, 오른쪽에 추가될 픽셀 크기, 아래쪽에 추가될 픽셀 크기)
//    * @param reduce (가로 오프셋(픽셀),y 세로 오프셋(픽셀),width 오프셋으로 부터의 넓이(픽셀),height 오프셋으로 부터의 높이(픽셀))
//    * @param directoryName
//    * @return
//    */
//  public static boolean setImgEffect(
//           String sourceFile,
//           String outFile,
//           int targetWidth,
//           int targetHeight,
//           String[] effect,
//           int[] expand,
//           int[] reduce,
//           String outFileType,
//           String directoryName)
//   {
//
//      XImg m1 = null;
//      XImg m2 = null;
//      XImg m3 = null;
//      
//      try {
//
//           if (directoryName != null) {
//               if (!FileUtil.directoryCheck(directoryName))
//                   FileUtil.createDirectory(directoryName);
//           }
//           else {
//               if (!FileUtil.directoryCheck(outFile))
//                   FileUtil.createDirectory(outFile);
//           }
//
//           /* 쓰레드 초기화 */
//           XImg.initThread();
//
//           XImg tmp;
//           XImg img = XImg.create();
//
//           /* 이미지 로딩 및 리사이징 */
//           img.load(sourceFile);
//
//           img.resize(targetWidth, targetHeight);
//           img.expand(expand[0], expand[1], expand[2], expand[3], 0xFFFFFF);
//           img.crop(reduce[0], reduce[1], reduce[2], reduce[3]);
//
//           String effectImg1 = null;
//           String effectImg2 = null;
//           String effectImg3 = null;
//           
//           if(effect.length == 3) {
//               effectImg1 = effect[0];
//               effectImg2 = effect[1];
//               effectImg3 = effect[2];
//           } else if(effect.length == 2) {
//               effectImg1 = effect[0];
//               effectImg2 = effect[1];
//           } else if(effect.length == 1) {
//               effectImg1 = effect[0];
//           }              
//               
//           if(!"".equals(effectImg1) && effectImg1 != null) {
//               m1 = XImg.createGlobal();
//               m1.load(effectImg1);
//           }
//              
//           if(!"".equals(effectImg2) && effectImg2 != null) {
//               m2 = XImg.createGlobal();
//               m2.load(effectImg2);
//           }
//              
//           if(!"".equals(effectImg3) && effectImg3 != null) {
//               m3 = XImg.createGlobal();
//               m3.load(effectImg3);
//           }
//           
//           /*
//            * 로드된 이미지에 필터를 적용해 변환한 후 저장한다. 이미지를 복제해 사용하는 이유는, 동일한 이미지에 다른
//            * 필터를 적용한 또다른 결과를 만들기 위해 원본을 유지할 필요가 있기 때문이다.
//            */
//           tmp = (XImg)img.clone(); // 이미지 변환을 위해 복제
//           tmp.mixMasks(m1, m2, m3);
//           
//           if(IMAGE_TYPE_BMP.equals(outFileType)) 
//               tmp.saveBmp(outFile);
//           else if(IMAGE_TYPE_GIP.equals(outFileType))
//               tmp.saveGif(outFile);
//           else if (IMAGE_TYPE_JPGE.equals(outFileType))
//               tmp.saveJpeg(outFile, 100);
//           else {
//               tmp.savePng(outFile);
//               removeChuckdKGD(outFile);
//           }
//               
//          // } else {
//          //     logger.error("이미지 변환 실패 [이미지 효과 설정 파일 입력 오류 ]");
//           //    return false;
//          // }
//       } catch (Exception e) {
//           logger.error("이미지 변환 실패 : " + e.getMessage());
//           return false;
//       } finally {
//           /*
//            * 쓰레드 클린업. try 블럭에서 생성했던 모든 이미지 객체가 여기서 삭제된다.
//            */
//           XImg.cleanupThread();
//
//           /*
//            * 마스크 이미지는 createGlobal로 성성했기 때문에 cleanupThread로는 삭제되지 않는다.
//            */
//           if(m1 != null) m1.dispose();
//           if(m2 != null) m2.dispose();
//           if(m3 != null) m3.dispose();
//       }
//       return true;
//   }
//  
//  public static boolean setImgEffectBlog(
//          String sourceFile,
//          String outFile,
//          int targetWidth,
//          int targetHeight,
//          String outFileType,
//          String directoryName)
//  {
//
//     XImg m1 = null;
//     XImg m2 = null;
//     XImg m3 = null;
//     
//     try {
//
//          if (directoryName != null) {
//              if (!FileUtil.directoryCheck(directoryName))
//                  FileUtil.createDirectory(directoryName);
//          }
//          else {
//              if (!FileUtil.directoryCheck(outFile))
//                  FileUtil.createDirectory(outFile);
//          }
//
//          XImg.initThread();
//
//          XImg tmp;
//          XImg img = XImg.create();
//
//          img.load(sourceFile);
//          img.resize(targetWidth, targetHeight);
//
//          tmp = (XImg)img.clone(); 
//          
//          if(IMAGE_TYPE_BMP.equals(outFileType)){ 
//              tmp.saveBmp(outFile);
//          }
//          else if(IMAGE_TYPE_GIP.equals(outFileType)){
//              tmp.saveGif(outFile);
//          }
//          else if (IMAGE_TYPE_JPGE.equals(outFileType)){
//              tmp.saveJpeg(outFile, 100);
//          }
//          else {
//              tmp.savePng(outFile);
//              removeChuckdKGD(outFile);
//          }
//
//      } catch (Exception e) {
//          logger.error("�̹��� ��ȯ ���� : " + e.getMessage());
//          return false;
//      } finally {
//
//          XImg.cleanupThread();
//
//          if(m1 != null) m1.dispose();
//          if(m2 != null) m2.dispose();
//          if(m3 != null) m3.dispose();
//      }
//      return true;
//  }
//    
//    public static void removeChuckdKGD (String filename) {
//        DataInputStream dis = null;
//        FileOutputStream fos = null;
//
//        try {
//            dis = new DataInputStream(new FileInputStream(filename));
//            
//            byte[] data = IOUtils.toByteArray(dis);
//    
//            if (data.length == 0) {
//                return;
//            }
//    
//            int chunkDataLenght = 0;
//            int chunkPosition = 0;
//            for (int i = 0; i < data.length; i++) {
//                if (data[i + 4] == 'b' && data[i + 5] == 'K'
//                    && data[i + 6] == 'G' && data[i + 7] == 'D') {
//                    chunkPosition = i;
//                    chunkDataLenght = (data[i++] << 4) | (data[i++] << 4)
//                                            | (data[i++] << 4) | data[i];
//                    break;
//                }
//                if (data[i + 4] == 'I' && data[i + 5] == 'D'
//                    && data[i + 6] == 'A' && data[i + 7] == 'T') {
//                    break;
//                }
//            }
//            
//            if (chunkPosition != 0) {
//                int fullChunkLenght = 12 + chunkDataLenght;
//    
//                System.arraycopy(data, chunkPosition + fullChunkLenght,
//                                 data, chunkPosition,
//                                 data.length - chunkPosition - fullChunkLenght);
//                
//                data = ArrayUtils.subarray(data, 0, data.length - fullChunkLenght);
//            }
//    
//            fos = new FileOutputStream(filename);
//            
//            fos.write(data);
//            fos.close();
//        } catch (Exception e) {
//            e.printStackTrace();
//            logger.warn("Cannot remove bKGD chunk ", e);
//        } finally {
//            IOUtils.closeQuietly(dis);
//            
//            if(fos != null) {
//                 try { 
//                     fos.close();
//                 } catch (Exception e) {
//                     
//                 }
//                
//            }
//        }
//    }
//   
}
